import MySQLdb
import MySQLdb.cursors
import servers
import utiles

host=servers.host
user=servers.user
passwd=servers.passwd
db_name=servers.db_name

#Este cursor es para hacer operaciones sin AUTOCOMMIT y poder usar TRANSACCIONES

host_remote=servers.host_remote
user_remote=servers.user_remote
passwd_remote=servers.passwd_remote
db_name_remote=servers.db_name_remote

#by diego - 2009 ########################################################################################
host_remote22=servers.host_remote22
user_remote22=servers.user_remote22
passwd_remote22=servers.passwd_remote22
db_name_remote22=servers.db_name_remote22
db_remote22=MySQLdb.connect(host=host_remote22,user=user_remote22,passwd=passwd_remote22,db=db_name_remote22, cursorclass=MySQLdb.cursors.DictCursor)
c2_remote22=db_remote22.cursor()
#by diego 2009 ###########################################################################################


#Este cursor es para hacer operaciones sin AUTOCOMMIT y poder usar TRANSACCIONES
db2=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name, cursorclass=MySQLdb.cursors.DictCursor)
c2=db2.cursor()


#Igual que c2 pero para el server REMOTO
db_remote=MySQLdb.connect(host=host_remote,user=user_remote,passwd=passwd_remote,db=db_name_remote, cursorclass=MySQLdb.cursors.DictCursor)
c2_remote=db_remote.cursor()

######################################################
# by diego agregada 03-02-2009
def executaRemoto(sql):
    global db_remote22
    global c2_remote22
  
    c2_remote22 = db_remote22.cursor()   
    c2_remote22.execute(sql)
    return c2_remote22.fetchall()
# by diego agregada 03-02-2009

###########################Funciones Transaccionales Remotas#########################################

def beginRemote():
    global db_remote
    global c2_remote
    
    global host_remote
    global user_remote
    global passwd_remote
    global db_name_remote
    
    c2_remote.close()
    db_remote.close()
    
    db_remote = MySQLdb.connect(host=host_remote,user=user_remote,passwd=passwd_remote,db=db_name_remote, cursorclass=MySQLdb.cursors.DictCursor)
    c2_remote = db_remote.cursor()   
    c2_remote.execute("start transaction")

def commitRemote():    
    global c2_remote
    c2_remote.execute("commit")

def rollbackRemote():
    global c2_remote
    c2_remote.execute("rollback")
    
def ordenCrudaDictRemote(consulta, previo="SELECT 1"):
    global c2_remote
    c2_remote.execute(consulta)
    utiles.logBD("ordenCrudaDictRemote: " + consulta)
    return c2_remote.fetchall()     

def executaSinCommitRemote(self,sql):
    global db_remote
    global c2_remote
    ultimoid = db2.insert_id()
    c2_remote.execute(sql)
    return ultimoid

def ordenCrudaResultDictRemote(consulta, previo="SELECT 1"):
    global c2_remote
    c2_remote.execute(consulta)
    utiles.logBD("ordenCrudaResultDictRemote: " + consulta)
    return c2_remote.fetchall()     

###########################Funciones Transaccionales#########################################################

def begin():
    global db2
    global c2 

    global host
    global user
    global passwd
    global db_name  

    c2.close()
    db2.close()

    db2 = MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name, cursorclass=MySQLdb.cursors.DictCursor)
    c2  = db2.cursor()   
    c2.execute("start transaction")

def commit():    
    global c2 
    c2.execute("commit")

def rollback():
    global c2 
    c2.execute("rollback")

def executaSinCommit(self,sql):
    global c2 
    c2.execute("set autocommit = 0")
    c2.execute(sql)
    utiles.logBD("executaSinCommit: " + sql)
    return ""

def ordenCrudaSinCommit(consulta):
    global c2 
    c2.execute(consulta)
    utiles.logBD("ordenCrudaSinCommit: " + consulta)
    return c2.fetchall()
    
def ordenCrudaDictSinCommit(consulta, previo="SELECT 1"):
    global c2 
    c2.execute(previo)
    c2.execute(consulta)
    utiles.logBD("ordenCrudaDictSinCommit: " + consulta)
    return c2.fetchall()

def ordenCrudaResultDictSinCommit(consulta, previo="SELECT 1"):
    global c2 
    c2.execute(previo)
    c2.execute(consulta)
    result = c2.fetchall()
    utiles.logBD("ordenCrudaResultDictSinCommit: " + consulta)
    if len(result):		
        return result[0]
    return []


########################Funciones NO Transaccionales #####################################################

def executa(self,sql):
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    utiles.logBD("executa: "+sql)
    c.execute(sql)
    ultimoid = db.insert_id()
    c.execute("set autocommit = 1")
    c.close()
    return ultimoid

# ejecuta la consulta pasada por argumento
# devuelve todos los resultados
def ordenCruda(consulta):
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    c.execute(consulta)
    utiles.logBD("ordenCruda: " + consulta)
    aux = c.fetchall()
    c.close()
    db.close()
    return aux
    
def ordenCrudaDict(consulta, previo="SELECT 1"):
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name, cursorclass=MySQLdb.cursors.DictCursor)
    c=db.cursor()
    utiles.logBD("ordenCrudaDict: " + consulta)
    c.execute(previo)
    c.execute(consulta)
    aux = c.fetchall()
    c.close()
    db.close()
    return aux

def ordenCrudaResultDict(consulta, previo="SELECT 1"):
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name, cursorclass=MySQLdb.cursors.DictCursor)
    c=db.cursor()
    utiles.logBD("ordenCrudaResultDict: "+consulta)
    c.execute(previo)
    c.execute(consulta)
    result = c.fetchall()
    c.close()
    db.close()
    
    if len(result):		
        return result[0]
    return []


########################FUNCIONES VARIAS############################################################

def executaSQL(self,camposSQL,tablaSQL,condicion):
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    utiles.logBD('executaSQL: Select %s from %s where %s' % (camposSQL,tablaSQL,condicion))
    c.execute("""Select %s from %s where %s""" % (camposSQL,tablaSQL,condicion))
    return c.fetchall()        
        
def executaResultSQL(self,camposSQL,tablaSQL,condicion):
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    utiles.logBD('executaResultSQL: Select %s from %s where %s' % (camposSQL,tablaSQL,condicion))
    c.execute("""Select %s from %s where %s""" % (camposSQL,tablaSQL,condicion))
    aux = c.fetchall()
    c.close()
    db.close()
    return aux[0][0]
    
def executaInsertSQL(self,tablaSQL,camposSQL):
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    utiles.logBD('executaInsertSQL: Insert into %s values %s ' % (tablaSQL,camposSQL))
    sql='Insert into %s values %s ' % (tablaSQL,camposSQL)
    c.execute(sql)
    ultimoid = db.insert_id()
    c.execute("set autocommit = 1")
    c.close()
    return ultimoid

def executaUpdateSQL(self,tablaSQL,camposSQL,condicionSQL):
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    utiles.logBD("executaUpdateSQL: UPDATE %s SET %s WHERE %s" % (tablaSQL,camposSQL,condicionSQL))
    sql ="UPDATE %s SET %s WHERE %s" % (tablaSQL,camposSQL,condicionSQL)
    c.execute(sql)
    c.execute("set autocommit = 1")
    c.close()
    return
    
def executaTruncateSQL(self,tablaSQL):
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    utiles.logBD("executaTruncateSQL: TRUNCATE TABLE %s "% (tablaSQL))
    sql ="TRUNCATE TABLE %s "% (tablaSQL)
    c.execute(sql)
    c.execute("set autocommit = 1")
    c.close()
    db.close()
        
#preguntas repetidas
#en que sucursal estoy?--> Lo define el usuario
def cuentafilas(self,camposSQL,tablaSQL,condicion):
    #arreglar el metodo, hago esta consulta 2 veces
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    utiles.logBD('cuantafilas: Select %s from %s where %s' % (camposSQL,tablaSQL,condicion))
    c.execute("""Select %s from %s where %s""" % (camposSQL,tablaSQL,condicion))
    aux = c.rowcount
    c.close()
    db.close()
    return aux
    
    
def buscaidticket(self):
    #ver en python como devolver el ultimo id del insertado
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    sql="SELECT idticket FROM `ventas` order by idticket desc"
    c.execute(sql)
    c.close()
    db.close()
        
def ultimoinsert(self):
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.insert_id()
    db.close()
    return c
    
# devuelve el nombre de las columnas para la
# generar la vista
def getColumnasVista(vista):
    consulta = "SELECT nombrecolumnas FROM listados WHERE nombre = '%s'" % vista
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    utiles.logBD("getColumnasVista: " + consulta)
    c.execute(consulta)
    resultado = c.fetchone()[0]
    c.close()
    db.close()
    return resultado.split(',')

# devuelve el nombre de las columnas para la
# generar la consulta de la base de datos
def getColumnasBD(vista):
    consulta = "SELECT columnas_bd FROM listados WHERE nombre = '%s'" % vista
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    utiles.logBD("getColumnasBD: " + consulta)
    c.execute(consulta)
    resultado = c.fetchone()[0]
    c.close()
    db.close()
    
    return resultado

#Saca la cant. de distintos valores para hacer la planilla de caja
def cuentafilasagrupado(self,camposSQL,tablaSQL,condicion):
    sucursal = utiles.getSucursalActiva()
    suc = sucursal[:2]+"-%"
    utiles.logBD("cuentafilasagrupado: "+str(self.fecha))
    consulta = "SELECT idformapagos as 'total' FROM ventastienepagos where idventa like '%s' AND %s group by idformapagos UNION select distinct (idvalor) as 'total' from cajachica where %s UNION (SELECT distinct idformapago FROM vtas_valores a,vtas_ctasctestienepagos b WHERE a.idrecibo=b.idrecibo AND %s group by idformapago)" % (str(suc),condicion,condicion,condicion)
    utiles.logBD("cuentafilasagrupado: "+consulta)
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    c.execute(consulta)
    aux= c.rowcount
    c.close()
    db.close()
    return aux

#retorna los valores de la caja
def cajavalores(self,camposSQL,tablaSQL,condicion,fecha):
    #consulta = "select idformaticket,idformapagos,descrivalor,sum(b.monto)as 'total' from ventas a, ventastienepagos b WHERE %s group by idformaticket,idformapagos,descrivalor" % (condicion)
    sucursal = utiles.getSucursalActiva()
    suc = sucursal[:2]+"-%"
    consulta = "select distinct (idformapagos) as 'valores' from ventas a, ventastienepagos b WHERE b.idventa like '%s' AND (a.idventa = b.idventa) and %s UNION select distinct (idvalor) as 'valores' from cajachica where %s UNION (SELECT distinct(idformapago) as 'valores' FROM vtas_valores a,vtas_ctasctestienepagos b WHERE a.idrecibo=b.idrecibo AND fecha='%s' group by idformapago) UNION (SELECT DISTINCT (idformapagos) AS 'vtas_ctasctes' FROM vtas_ctasctes a, ventas v WHERE a.idventa = v.idventa AND fecha = '%s')" % (suc,condicion,fecha,(str(self.fecha)),(str(self.fecha)))
    #consulta = "SELECT idformapagos,descrivalor,sum(monto) AS 'TOTAL' FROM `ventastienepagos` where "+str(condicion)+" group by idformapagos"
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    utiles.logBD("cajavalores: " + consulta)
    c.execute(consulta)
    aux = c.fetchall()
    c.close()
    db.close()
    return aux
    
def executaSumadorSQL(self,camposSQL,tablaSQL,condicion):
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    utiles.logBD('executaSumadorSQL: Select sum(monto) from %s where %s' % (tablaSQL,condicion))
    c.execute("""Select sum(monto) from %s where %s""" % (tablaSQL,condicion))
    aux = c.fetchall()
    c.close()
    db.close()
    return aux
    
    
def cajaValoresDiscrimina(self, camposSQL,condicion1,condicion2):
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    executa = "select sum(b.monto)as 'Total' from ventas a, ventastienepagos b where (a.idventa = b.idventa) and %s UNION select sum(b.monto)as 'Total' from ventas a, ventastienepagos b where (a.idventa = b.idventa) and %s " %(condicion1,condicion2)
    utiles.logBD("cajaValoresDiscrimina: " + executa)
    c.execute(executa)
    return c.fetchall()
    
def cajaValoresDetalles(self,camposSQL,condicion):
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    executa = "SELECT distinct(a.nrofactura), a.fecha,a.idformaticket,c.nombre,a.totalfactura as 'Monto',b.sucursal, 'Ventas' FROM ventas a,ventastieneproductos b, cliente c WHERE %s and (b.nrofactura=a.nrofactura) and (a.idformaticket=b.idformaticket) and (a.idventa=b.idticket) and (a.idcliente=c.idcliente) union (Select idcaja, fecha,tipoalta,destinatario,monto as 'Monto',1,'Mov. de Caja' from cajachica where %s order by tipoalta desc)" % (condicion,condicion)
    utiles.logBD("cajaValoresDetalles: " + executa)
    c.execute(executa)
    return c.fetchall()

def cajaValoresDetallesCuentaFilas(self,camposSQL,condicion):
    db=MySQLdb.connect(host=host,user=user,passwd=passwd,db=db_name)
    c=db.cursor()
    executa = "SELECT distinct(a.nrofactura), a.fecha,a.idformaticket,c.nombre,(select SUM(monto) from ventastienepagos where fecha=a.fecha and (nrofactura=b.nrofactura) and (nrofactura=a.nrofactura)) as 'Monto',b.sucursal, 'Ventas' FROM ventas a,ventastieneproductos b, cliente c WHERE %s and (b.nrofactura=a.nrofactura) and (a.idformaticket=b.idformaticket) and (a.idventa=b.idticket) and (a.idcliente=c.idcliente) union (Select idcaja, fecha,tipoalta,destinatario,monto as 'Monto',1,'Mov. de Caja' from cajachica where %s order by tipoalta desc)" % (condicion,condicion)
    utiles.logBD("cajaValoresDetallesCuentailas: " + executa)
    c.execute(executa)
    return c.rowcount